#!/usr/bin/env python
# vim:fileencoding=utf-8
import json
import re
from collections import OrderedDict
from urllib.parse import urlencode, urljoin

from mechanize import Request

from calibre import browser, random_user_agent
from calibre.web.feeds.news import BasicNewsRecipe, classes


class HBR(BasicNewsRecipe):
    title = 'Harvard Business Review'
    __author__ = 'unkn0wn, updated by ping'
    description = (
        'Harvard Business Review is the leading destination for smart management thinking. '
        'Through its flagship magazine, books, and digital content and tools published on HBR.org, '
        'Harvard Business Review aims to provide professionals around the world with rigorous insights '
        'and best practices to help lead themselves and their organizations more effectively and to '
        'make a positive impact.'
    )
    language = 'en'
    masthead_url = 'https://hbr.org/resources/css/images/hbr_logo.svg'
    publication_type = 'magazine'
    encoding = 'utf-8'
    remove_javascript = True
    no_stylesheets = True
    auto_cleanup = False
    compress_news_images = True
    ignore_duplicate_articles = {'url'}
    base_url = 'https://hbr.org'

    remove_attributes = ['height', 'width', 'style']
    extra_css = '''
        h1.article-hed { font-size: x-large; margin-bottom: 0.4rem; }
        .article-dek {  font-size: large; font-style: italic; margin-bottom: 1rem; }
        .article-byline { margin-top: 0.7rem; font-size: medium; font-style: normal; font-weight: bold; }
        .pub-date { font-size: small; margin-bottom: 1rem; }
        img {
            display: block; margin-bottom: 0.3rem; max-width: 100%; height: auto;
            box-sizing: border-box;
        }
        .container--caption-credits-hero, .container--caption-credits-inline, span.credit { font-size: small; }
        .question { font-weight: bold; }
        .description-text {
            margin: 1rem 0;
            border-top: 1px solid gray;
            padding-top: 0.5rem;
            font-style: italic;
        }
        '''

    keep_only_tags = [
        classes(
            'headline-container article-dek-group pub-date hero-image-content '
            'article-body standard-content'
        ),
    ]

    remove_tags = [
        classes(
            'left-rail--container translate-message follow-topic '
            'newsletter-container by-prefix related-topics--common'
        ),
        dict(name=['article-sidebar']),
    ]

    def preprocess_raw_html(self, raw_html, article_url):
        soup = self.soup(raw_html)

        # break author byline out of list
        byline_list = soup.find('ul', class_='article-byline-list')
        if byline_list:
            byline = byline_list.parent
            byline.append(
                ', '.join(
                    [
                        self.tag_to_string(author)
                        for author in byline_list.find_all(class_='article-author')
                    ]
                )
            )
            byline_list.decompose()

        # Extract full article content
        content_ele = soup.find(
            'content',
            attrs={
                'data-index': True,
                'data-page-year': True,
                'data-page-month': True,
                'data-page-seo-title': True,
                'data-page-slug': True,
            },
        )
        endpoint_url = 'https://hbr.org/api/article/piano/content?' + urlencode(
            {
                'year': content_ele['data-page-year'],
                'month': content_ele['data-page-month'],
                'seotitle': content_ele['data-page-seo-title'],
            }
        )
        data = {
            'contentKey': content_ele['data-index'],
            'pageSlug': content_ele['data-page-slug'],
        }
        headers = {
            'User-Agent': random_user_agent(),
            'Pragma': 'no-cache',
            'Cache-Control': 'no-cache',
            'Content-Type': 'application/json',
            'Referer': article_url,
        }
        br = browser()
        req = Request(
            endpoint_url,
            headers=headers,
            data=json.dumps(data),
            method='POST',
            timeout=self.timeout,
        )
        res = br.open(req)
        article = json.loads(res.read())
        new_soup = self.soup(article['content'])
        # clear out existing partial content
        for c in list(content_ele.children):
            c.extract()  # use extract() instead of decompose() because of strings
        content_ele.append(new_soup.body)
        return str(soup)

    recipe_specific_options = {
        'issue': {
            'short': 'Enter the Issue Number you want to download ',
            'long': 'For example, 2403'
        }
    }

    def parse_index(self):
        d = self.recipe_specific_options.get('issue')
        if not (d and isinstance(d, str)):
            soup = self.index_to_soup(f'{self.base_url}/magazine')
            a = soup.find('a', href=lambda x: x and x.startswith('/archive-toc/'))
            cov_url = a.find('img', attrs={'src': True})['src']
            self.cover_url = urljoin(self.base_url, cov_url)
            issue_url = urljoin(self.base_url, a['href'])
        else:
            issue_url = 'https://hbr.org/archive-toc/BR' + d
            mobj = re.search(r'archive-toc/(?P<issue>(BR)?\d+)\b', issue_url)
            if mobj:
                self.cover_url = f'https://hbr.org/resources/images/covers/{mobj.group("issue")}_500.png'

        self.log('Downloading issue:', issue_url)
        soup = self.index_to_soup(issue_url)
        issue_title = soup.find('h1')
        if issue_title:
            self.timefmt = f' [{self.tag_to_string(issue_title)}]'

        feeds = OrderedDict()
        for h3 in soup.find_all('h3', attrs={'class': 'hed'}):
            article_link_ele = h3.find('a')
            if not article_link_ele:
                continue

            article_ele = h3.find_next_sibling(
                'div', attrs={'class': 'stream-item-info'}
            )
            if not article_ele:
                continue

            title = self.tag_to_string(article_link_ele)
            url = urljoin(self.base_url, article_link_ele['href'])

            authors_ele = article_ele.select('ul.byline li')
            authors = ', '.join([self.tag_to_string(a) for a in authors_ele])

            article_desc = ''
            dek_ele = h3.find_next_sibling('div', attrs={'class': 'dek'})
            if dek_ele:
                article_desc = self.tag_to_string(dek_ele) + ' | ' + authors
            section_ele = (
                h3.findParent('li')
                .find_previous_sibling('div', **classes('stream-section-label'))
                .find('h4')
            )
            section_title = self.tag_to_string(section_ele).title()
            feeds.setdefault(section_title, []).append(
                {'title': title, 'url': url, 'description': article_desc}
            )
        return feeds.items()
